// ************************************************************************ //
// The types declared in this file were generated from data read from the
// WSDL File described below:
// WSDL     : http://192.168.1.55:8080/axis/services/IotomessagePort?wsdl
//  >Import : http://192.168.1.55:8080/axis/services/IotomessagePort?wsdl:0
// Encoding : UTF-8
// Version  : 1.0
// (2008-08-07 10:32:23 - - $Rev: 10138 $)
// ************************************************************************ //

unit IotomessagePort;

interface

uses InvokeRegistry, SOAPHTTPClient, Types, XSBuiltIns;

const
  IS_OPTN = $0001;


type

  // ************************************************************************ //
  // The following types, referred to in the WSDL document are not being represented
  // in this file. They are either aliases[@] of other types represented or were referred
  // to but never[!] declared in the document. The types from the latter category
  // typically map to predefined/known XML or Borland types; however, they could also 
  // indicate incorrect WSDL documents that failed to declare or import a schema type.
  // ************************************************************************ //
  // !:string          - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:int             - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:base64Binary    - "http://www.w3.org/2001/XMLSchema"[Gbl]

  AuthInfo             = class;                 { "urn:ototype"[GblCplx] }
  MsgSendStatReq       = class;                 { "urn:ototype"[GblCplx] }
  MsgInfo              = class;                 { "urn:ototype"[GblCplx] }
  MsgSearchReq         = class;                 { "urn:ototype"[GblCplx] }
  MsgRecvInfo          = class;                 { "urn:ototype"[GblCplx] }
  MsgRecvReq           = class;                 { "urn:ototype"[GblCplx] }
  MsgSearchCountReq    = class;                 { "urn:ototype"[GblCplx] }
  SQLReq               = class;                 { "urn:ototype"[GblCplx] }
  FaxContactor         = class;                 { "urn:ototype"[GblCplx] }
  FaxFile              = class;                 { "urn:ototype"[GblCplx] }
  Fax                  = class;                 { "urn:ototype"[GblCplx] }
  SendFaxWrapper       = class;                 { "urn:ototype"[GblCplx] }
  EFaxResult           = class;                 { "urn:ototype"[GblCplx] }
  SendFaxResultWrapper = class;                 { "urn:ototype"[GblCplx] }
  SendFaxStateWrapper  = class;                 { "urn:ototype"[GblCplx] }
  ReceiveFaxWrapper    = class;                 { "urn:ototype"[GblCplx] }
  ReceiveFaxResultWrapper = class;              { "urn:ototype"[GblCplx] }
  MsgSendReq           = class;                 { "urn:ototype"[GblCplx] }



  // ************************************************************************ //
  // XML       : AuthInfo, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  AuthInfo = class(TRemotable)
  private
    FUserName: WideString;
    FAuthPass: WideString;
    FTimestamp: WideString;
  published
    property UserName:  WideString  read FUserName write FUserName;
    property AuthPass:  WideString  read FAuthPass write FAuthPass;
    property Timestamp: WideString  read FTimestamp write FTimestamp;
  end;



  // ************************************************************************ //
  // XML       : MsgSendStatReq, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  MsgSendStatReq = class(TRemotable)
  private
    FMsgType: WideString;
    FVersion: WideString;
    FBatchID: WideString;
    FAuthInfo: AuthInfo;
  public
    destructor Destroy; override;
  published
    property MsgType:  WideString  read FMsgType write FMsgType;
    property Version:  WideString  read FVersion write FVersion;
    property BatchID:  WideString  read FBatchID write FBatchID;
    property AuthInfo: AuthInfo    read FAuthInfo write FAuthInfo;
  end;



  // ************************************************************************ //
  // XML       : MsgInfo, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  MsgInfo = class(TRemotable)
  private
    FCreateDate: WideString;
    FContent: WideString;
    FSendDate: WideString;
    FSmsType: Integer;
    FState: Integer;
    FMobile: WideString;
  published
    property CreateDate: WideString  read FCreateDate write FCreateDate;
    property Content:    WideString  read FContent write FContent;
    property SendDate:   WideString  read FSendDate write FSendDate;
    property SmsType:    Integer     read FSmsType write FSmsType;
    property State:      Integer     read FState write FState;
    property Mobile:     WideString  read FMobile write FMobile;
  end;

  ArrayOfMsgInfo = array of MsgInfo;            { "urn:ototype"[GblCplx] }


  // ************************************************************************ //
  // XML       : MsgSearchReq, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  MsgSearchReq = class(TRemotable)
  private
    FMsgType: WideString;
    FVersion: WideString;
    FAuthInfo: AuthInfo;
    FSQL: WideString;
  public
    destructor Destroy; override;
  published
    property MsgType:  WideString  read FMsgType write FMsgType;
    property Version:  WideString  read FVersion write FVersion;
    property AuthInfo: AuthInfo    read FAuthInfo write FAuthInfo;
    property SQL:      WideString  read FSQL write FSQL;
  end;



  // ************************************************************************ //
  // XML       : MsgRecvInfo, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  MsgRecvInfo = class(TRemotable)
  private
    FRecvDate: WideString;
    FDestMobile: WideString;
    FSendAddi: WideString;
    FRecvAddi: WideString;
    FContent: WideString;
  published
    property RecvDate:   WideString  read FRecvDate write FRecvDate;
    property DestMobile: WideString  read FDestMobile write FDestMobile;
    property SendAddi:   WideString  read FSendAddi write FSendAddi;
    property RecvAddi:   WideString  read FRecvAddi write FRecvAddi;
    property Content:    WideString  read FContent write FContent;
  end;

  ArrayOfMsgRecv = array of MsgRecvInfo;        { "urn:ototype"[GblCplx] }


  // ************************************************************************ //
  // XML       : MsgRecvReq, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  MsgRecvReq = class(TRemotable)
  private
    FMsgType: WideString;
    FVersion: WideString;
    FAuthInfo: AuthInfo;
  public
    destructor Destroy; override;
  published
    property MsgType:  WideString  read FMsgType write FMsgType;
    property Version:  WideString  read FVersion write FVersion;
    property AuthInfo: AuthInfo    read FAuthInfo write FAuthInfo;
  end;



  // ************************************************************************ //
  // XML       : MsgSearchCountReq, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  MsgSearchCountReq = class(TRemotable)
  private
    FMsgType: WideString;
    FVersion: WideString;
    FAuthInfo: AuthInfo;
    FSQL: WideString;
  public
    destructor Destroy; override;
  published
    property MsgType:  WideString  read FMsgType write FMsgType;
    property Version:  WideString  read FVersion write FVersion;
    property AuthInfo: AuthInfo    read FAuthInfo write FAuthInfo;
    property SQL:      WideString  read FSQL write FSQL;
  end;



  // ************************************************************************ //
  // XML       : SQLReq, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  SQLReq = class(TRemotable)
  private
    FMsgType: WideString;
    FVersion: WideString;
    FAuthInfo: AuthInfo;
    FSQL: WideString;
  public
    destructor Destroy; override;
  published
    property MsgType:  WideString  read FMsgType write FMsgType;
    property Version:  WideString  read FVersion write FVersion;
    property AuthInfo: AuthInfo    read FAuthInfo write FAuthInfo;
    property SQL:      WideString  read FSQL write FSQL;
  end;



  // ************************************************************************ //
  // XML       : FaxContactor, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  FaxContactor = class(TRemotable)
  private
    FcontactorID: WideString;
    FcontactorID_Specified: boolean;
    Fcontactor: WideString;
    Fcontactor_Specified: boolean;
    FfaxNumber: WideString;
    FfaxNumber_Specified: boolean;
    Fcompany: WideString;
    Fcompany_Specified: boolean;
    procedure SetcontactorID(Index: Integer; const AWideString: WideString);
    function  contactorID_Specified(Index: Integer): boolean;
    procedure Setcontactor(Index: Integer; const AWideString: WideString);
    function  contactor_Specified(Index: Integer): boolean;
    procedure SetfaxNumber(Index: Integer; const AWideString: WideString);
    function  faxNumber_Specified(Index: Integer): boolean;
    procedure Setcompany(Index: Integer; const AWideString: WideString);
    function  company_Specified(Index: Integer): boolean;
  published
    property contactorID: WideString  Index (IS_OPTN) read FcontactorID write SetcontactorID stored contactorID_Specified;
    property contactor:   WideString  Index (IS_OPTN) read Fcontactor write Setcontactor stored contactor_Specified;
    property faxNumber:   WideString  Index (IS_OPTN) read FfaxNumber write SetfaxNumber stored faxNumber_Specified;
    property company:     WideString  Index (IS_OPTN) read Fcompany write Setcompany stored company_Specified;
  end;

  ArrayOfFaxContactor = array of FaxContactor;   { "urn:ototype"[GblCplx] }


  // ************************************************************************ //
  // XML       : FaxFile, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  FaxFile = class(TRemotable)
  private
    Ffile_: TByteDynArray;
    Ffile__Specified: boolean;
    FfileName: WideString;
    FfileName_Specified: boolean;
    FfileURL: WideString;
    FfileURL_Specified: boolean;
    FfileType: WideString;
    FfileType_Specified: boolean;
    FfaxPages: Integer;
    procedure Setfile_(Index: Integer; const ATByteDynArray: TByteDynArray);
    function  file__Specified(Index: Integer): boolean;
    procedure SetfileName(Index: Integer; const AWideString: WideString);
    function  fileName_Specified(Index: Integer): boolean;
    procedure SetfileURL(Index: Integer; const AWideString: WideString);
    function  fileURL_Specified(Index: Integer): boolean;
    procedure SetfileType(Index: Integer; const AWideString: WideString);
    function  fileType_Specified(Index: Integer): boolean;
  published
    property file_:    TByteDynArray  Index (IS_OPTN) read Ffile_ write Setfile_ stored file__Specified;
    property fileName: WideString     Index (IS_OPTN) read FfileName write SetfileName stored fileName_Specified;
    property fileURL:  WideString     Index (IS_OPTN) read FfileURL write SetfileURL stored fileURL_Specified;
    property fileType: WideString     Index (IS_OPTN) read FfileType write SetfileType stored fileType_Specified;
    property faxPages: Integer        read FfaxPages write FfaxPages;
  end;

  ArrayOfFaxFile = array of FaxFile;            { "urn:ototype"[GblCplx] }


  // ************************************************************************ //
  // XML       : Fax, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  Fax = class(TRemotable)
  private
    Fsender: FaxContactor;
    Fsender_Specified: boolean;
    Freceiver: ArrayOfFaxContactor;
    Freceiver_Specified: boolean;
    FsendTime: WideString;
    FsendTime_Specified: boolean;
    Ffiles: ArrayOfFaxFile;
    Ffiles_Specified: boolean;
    FresendTimes: Integer;
    FresendDelay: Integer;
    procedure Setsender(Index: Integer; const AFaxContactor: FaxContactor);
    function  sender_Specified(Index: Integer): boolean;
    procedure Setreceiver(Index: Integer; const AArrayOfFaxContactor: ArrayOfFaxContactor);
    function  receiver_Specified(Index: Integer): boolean;
    procedure SetsendTime(Index: Integer; const AWideString: WideString);
    function  sendTime_Specified(Index: Integer): boolean;
    procedure Setfiles(Index: Integer; const AArrayOfFaxFile: ArrayOfFaxFile);
    function  files_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property sender:      FaxContactor         Index (IS_OPTN) read Fsender write Setsender stored sender_Specified;
    property receiver:    ArrayOfFaxContactor  Index (IS_OPTN) read Freceiver write Setreceiver stored receiver_Specified;
    property sendTime:    WideString           Index (IS_OPTN) read FsendTime write SetsendTime stored sendTime_Specified;
    property files:       ArrayOfFaxFile       Index (IS_OPTN) read Ffiles write Setfiles stored files_Specified;
    property resendTimes: Integer              read FresendTimes write FresendTimes;
    property resendDelay: Integer              read FresendDelay write FresendDelay;
  end;



  // ************************************************************************ //
  // XML       : SendFaxWrapper, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  SendFaxWrapper = class(TRemotable)
  private
    FuserID: WideString;
    FuserID_Specified: boolean;
    FpassWord: WideString;
    FpassWord_Specified: boolean;
    FappCode: WideString;
    FappCode_Specified: boolean;
    Ffax: Fax;
    Ffax_Specified: boolean;
    procedure SetuserID(Index: Integer; const AWideString: WideString);
    function  userID_Specified(Index: Integer): boolean;
    procedure SetpassWord(Index: Integer; const AWideString: WideString);
    function  passWord_Specified(Index: Integer): boolean;
    procedure SetappCode(Index: Integer; const AWideString: WideString);
    function  appCode_Specified(Index: Integer): boolean;
    procedure Setfax(Index: Integer; const AFax: Fax);
    function  fax_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property userID:   WideString  Index (IS_OPTN) read FuserID write SetuserID stored userID_Specified;
    property passWord: WideString  Index (IS_OPTN) read FpassWord write SetpassWord stored passWord_Specified;
    property appCode:  WideString  Index (IS_OPTN) read FappCode write SetappCode stored appCode_Specified;
    property fax:      Fax         Index (IS_OPTN) read Ffax write Setfax stored fax_Specified;
  end;



  // ************************************************************************ //
  // XML       : EFaxResult, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  EFaxResult = class(TRemotable)
  private
    FresultCode: Integer;
    FresultInfo: WideString;
    FresultInfo_Specified: boolean;
    procedure SetresultInfo(Index: Integer; const AWideString: WideString);
    function  resultInfo_Specified(Index: Integer): boolean;
  published
    property resultCode: Integer     read FresultCode write FresultCode;
    property resultInfo: WideString  Index (IS_OPTN) read FresultInfo write SetresultInfo stored resultInfo_Specified;
  end;



  // ************************************************************************ //
  // XML       : SendFaxResultWrapper, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  SendFaxResultWrapper = class(TRemotable)
  private
    FsendFaxResult: EFaxResult;
    FsendFaxResult_Specified: boolean;
    procedure SetsendFaxResult(Index: Integer; const AEFaxResult: EFaxResult);
    function  sendFaxResult_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property sendFaxResult: EFaxResult  Index (IS_OPTN) read FsendFaxResult write SetsendFaxResult stored sendFaxResult_Specified;
  end;



  // ************************************************************************ //
  // XML       : SendFaxStateWrapper, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  SendFaxStateWrapper = class(TRemotable)
  private
    FuserID: WideString;
    FuserID_Specified: boolean;
    FpassWord: WideString;
    FpassWord_Specified: boolean;
    FappCode: WideString;
    FappCode_Specified: boolean;
    FfaxID: WideString;
    FfaxID_Specified: boolean;
    procedure SetuserID(Index: Integer; const AWideString: WideString);
    function  userID_Specified(Index: Integer): boolean;
    procedure SetpassWord(Index: Integer; const AWideString: WideString);
    function  passWord_Specified(Index: Integer): boolean;
    procedure SetappCode(Index: Integer; const AWideString: WideString);
    function  appCode_Specified(Index: Integer): boolean;
    procedure SetfaxID(Index: Integer; const AWideString: WideString);
    function  faxID_Specified(Index: Integer): boolean;
  published
    property userID:   WideString  Index (IS_OPTN) read FuserID write SetuserID stored userID_Specified;
    property passWord: WideString  Index (IS_OPTN) read FpassWord write SetpassWord stored passWord_Specified;
    property appCode:  WideString  Index (IS_OPTN) read FappCode write SetappCode stored appCode_Specified;
    property faxID:    WideString  Index (IS_OPTN) read FfaxID write SetfaxID stored faxID_Specified;
  end;



  // ************************************************************************ //
  // XML       : ReceiveFaxWrapper, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  ReceiveFaxWrapper = class(TRemotable)
  private
    FuserID: WideString;
    FuserID_Specified: boolean;
    FpassWord: WideString;
    FpassWord_Specified: boolean;
    Fappcode: WideString;
    Fappcode_Specified: boolean;
    FreceiverNumber: WideString;
    FreceiverNumber_Specified: boolean;
    FsenderNumber: WideString;
    FsenderNumber_Specified: boolean;
    FstartTime: WideString;
    FstartTime_Specified: boolean;
    FendTime: WideString;
    FendTime_Specified: boolean;
    procedure SetuserID(Index: Integer; const AWideString: WideString);
    function  userID_Specified(Index: Integer): boolean;
    procedure SetpassWord(Index: Integer; const AWideString: WideString);
    function  passWord_Specified(Index: Integer): boolean;
    procedure Setappcode(Index: Integer; const AWideString: WideString);
    function  appcode_Specified(Index: Integer): boolean;
    procedure SetreceiverNumber(Index: Integer; const AWideString: WideString);
    function  receiverNumber_Specified(Index: Integer): boolean;
    procedure SetsenderNumber(Index: Integer; const AWideString: WideString);
    function  senderNumber_Specified(Index: Integer): boolean;
    procedure SetstartTime(Index: Integer; const AWideString: WideString);
    function  startTime_Specified(Index: Integer): boolean;
    procedure SetendTime(Index: Integer; const AWideString: WideString);
    function  endTime_Specified(Index: Integer): boolean;
  published
    property userID:         WideString  Index (IS_OPTN) read FuserID write SetuserID stored userID_Specified;
    property passWord:       WideString  Index (IS_OPTN) read FpassWord write SetpassWord stored passWord_Specified;
    property appcode:        WideString  Index (IS_OPTN) read Fappcode write Setappcode stored appcode_Specified;
    property receiverNumber: WideString  Index (IS_OPTN) read FreceiverNumber write SetreceiverNumber stored receiverNumber_Specified;
    property senderNumber:   WideString  Index (IS_OPTN) read FsenderNumber write SetsenderNumber stored senderNumber_Specified;
    property startTime:      WideString  Index (IS_OPTN) read FstartTime write SetstartTime stored startTime_Specified;
    property endTime:        WideString  Index (IS_OPTN) read FendTime write SetendTime stored endTime_Specified;
  end;



  // ************************************************************************ //
  // XML       : ReceiveFaxResultWrapper, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  ReceiveFaxResultWrapper = class(TRemotable)
  private
    FreceiveFaxResult: EFaxResult;
    FreceiveFaxResult_Specified: boolean;
    procedure SetreceiveFaxResult(Index: Integer; const AEFaxResult: EFaxResult);
    function  receiveFaxResult_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property receiveFaxResult: EFaxResult  Index (IS_OPTN) read FreceiveFaxResult write SetreceiveFaxResult stored receiveFaxResult_Specified;
  end;

  Array_Of_string = array of WideString;        { "http://www.w3.org/2001/XMLSchema"[GblUbnd] }


  // ************************************************************************ //
  // XML       : MsgSendReq, global, <complexType>
  // Namespace : urn:ototype
  // ************************************************************************ //
  MsgSendReq = class(TRemotable)
  private
    FMsgType: WideString;
    FVersion: WideString;
    FAuthInfo: AuthInfo;
    FSmsType: Integer;
    FContent: WideString;
    FSendURL: WideString;
    FScheduleDate: WideString;
    FML: Array_Of_string;
    FML_Specified: boolean;
    FCreateDate: WideString;
    FWordLength: Integer;
    FPrioprity: Integer;
    procedure SetML(Index: Integer; const AArray_Of_string: Array_Of_string);
    function  ML_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property MsgType:      WideString       read FMsgType write FMsgType;
    property Version:      WideString       read FVersion write FVersion;
    property AuthInfo:     AuthInfo         read FAuthInfo write FAuthInfo;
    property SmsType:      Integer          read FSmsType write FSmsType;
    property Content:      WideString       read FContent write FContent;
    property SendURL:      WideString       read FSendURL write FSendURL;
    property ScheduleDate: WideString       read FScheduleDate write FScheduleDate;
    property ML:           Array_Of_string  Index (IS_OPTN) read FML write SetML stored ML_Specified;
    property CreateDate:   WideString       read FCreateDate write FCreateDate;
    property WordLength:   Integer          read FWordLength write FWordLength;
    property Prioprity:    Integer          read FPrioprity write FPrioprity;
  end;


  // ************************************************************************ //
  // Namespace : urn:otomessageIntf-Iotomessage
  // soapAction: urn:otomessageIntf-Iotomessage#%operationName%
  // transport : http://schemas.xmlsoap.org/soap/http
  // style     : rpc
  // binding   : IotomessagePortSoapBinding
  // service   : Iotomessageservice
  // port      : IotomessagePort
  // URL       : http://192.168.1.55:8080/axis/services/IotomessagePort
  // ************************************************************************ //
  Iotomessage = interface(IInvokable)
  ['{0D8964AD-B9EA-3709-A489-334EF1F9ACF9}']
    function  TestLink(const Value: WideString): WideString; stdcall;
    procedure MsgSend(const MsgSendReq: MsgSendReq; out MsgType: WideString; out Version: WideString; out hRect: Integer; out BatchID: Integer); stdcall;
    procedure MsgSendStat(const MsgSendStatReq: MsgSendStatReq; out MsgType: WideString; out Version: WideString; out MsgSendStatInfo: ArrayOfMsgInfo; out hRet: Integer); stdcall;
    procedure MsgSearch(const MsgSearchReq: MsgSearchReq; out MsgType: WideString; out Version: WideString; out MsgSearchInfo: ArrayOfMsgRecv; out MinId: WideString; out hRet: Integer
                        ); stdcall;
    procedure MsgRecv(const MsgRecvReq: MsgRecvReq; out MsgType: WideString; out Version: WideString; out MsgRecvInfo: ArrayOfMsgRecv; out hRet: Integer); stdcall;
    procedure MsgSearchCount(const MsgSearchCountReq: MsgSearchCountReq; out MsgType: WideString; out Version: WideString; out Count: WideString; out hRet: Integer); stdcall;
    function  SQL(const SQLReq: SQLReq; out MsgType: WideString; out Version: WideString; out hRet: Integer): WideString; stdcall;
    function  CheckContent(const Auth_Info: AuthInfo; const content_str: WideString; out hRet: Integer): WideString; stdcall;
    function  SendMessageBatch(const username: WideString; const SubId: WideString; const Password: WideString; const timeStamp: WideString; const Msg: WideString; const Destnumbers: WideString; 
                               const ScheduleDate: WideString; const msg_type: Integer): Integer; stdcall;
    function  AddUser(const Auth_Info: AuthInfo; const authCode: WideString): Integer; stdcall;
    function  DeleteUser(const Auth_Info: AuthInfo; const authCode: WideString): Integer; stdcall;
    function  UpdateUser(const Auth_Info: AuthInfo; const authCode: WideString; const newPassWord: WideString): Integer; stdcall;
    function  ValidUser(const Auth_Info: AuthInfo): Integer; stdcall;
    function  sendFax(const parameters: SendFaxWrapper): SendFaxResultWrapper; stdcall;
    function  sendFaxState(const parameters: SendFaxStateWrapper): EFaxResult; stdcall;
    function  receiveFax(const parameters: ReceiveFaxWrapper): ReceiveFaxResultWrapper; stdcall;
  end;

function GetIotomessage(defWSDL: string = '';defURL: string = '';UseWSDL: Boolean=System.False;
  Addr: string=''; HTTPRIO: THTTPRIO = nil): Iotomessage;

implementation
  uses SysUtils;

function GetIotomessage(defWSDL: string = '';defURL: string = '';UseWSDL: Boolean=System.False;
  Addr: string=''; HTTPRIO: THTTPRIO = nil): Iotomessage;
const
  //defWSDL = 'http://192.168.1.196:8080/axis/services/IotomessagePort?wsdl';
  //defURL  = 'http://192.168.1.196:8080/axis/services/IotomessagePort';
  defSvc  = 'Iotomessageservice';
  defPrt  = 'IotomessagePort';
var
  RIO: THTTPRIO;
begin
  Result := nil;
  if (Addr = '') then
  begin
    if UseWSDL then
      Addr := defWSDL
    else
      Addr := defURL;
  end;
  if HTTPRIO = nil then
    RIO := THTTPRIO.Create(nil)
  else
    RIO := HTTPRIO;
  try
    Result := (RIO as Iotomessage);
    if UseWSDL then
    begin
      RIO.WSDLLocation := Addr;
      RIO.Service := defSvc;
      RIO.Port := defPrt;
    end else
      RIO.URL := Addr;
  finally
    if (Result = nil) and (HTTPRIO = nil) then
      RIO.Free;
  end;
end;


destructor MsgSendStatReq.Destroy;
begin
  FreeAndNil(FAuthInfo);
  inherited Destroy;
end;

destructor MsgSearchReq.Destroy;
begin
  FreeAndNil(FAuthInfo);
  inherited Destroy;
end;

destructor MsgRecvReq.Destroy;
begin
  FreeAndNil(FAuthInfo);
  inherited Destroy;
end;

destructor MsgSearchCountReq.Destroy;
begin
  FreeAndNil(FAuthInfo);
  inherited Destroy;
end;

destructor SQLReq.Destroy;
begin
  FreeAndNil(FAuthInfo);
  inherited Destroy;
end;

procedure FaxContactor.SetcontactorID(Index: Integer; const AWideString: WideString);
begin
  FcontactorID := AWideString;
  FcontactorID_Specified := True;
end;

function FaxContactor.contactorID_Specified(Index: Integer): boolean;
begin
  Result := FcontactorID_Specified;
end;

procedure FaxContactor.Setcontactor(Index: Integer; const AWideString: WideString);
begin
  Fcontactor := AWideString;
  Fcontactor_Specified := True;
end;

function FaxContactor.contactor_Specified(Index: Integer): boolean;
begin
  Result := Fcontactor_Specified;
end;

procedure FaxContactor.SetfaxNumber(Index: Integer; const AWideString: WideString);
begin
  FfaxNumber := AWideString;
  FfaxNumber_Specified := True;
end;

function FaxContactor.faxNumber_Specified(Index: Integer): boolean;
begin
  Result := FfaxNumber_Specified;
end;

procedure FaxContactor.Setcompany(Index: Integer; const AWideString: WideString);
begin
  Fcompany := AWideString;
  Fcompany_Specified := True;
end;

function FaxContactor.company_Specified(Index: Integer): boolean;
begin
  Result := Fcompany_Specified;
end;

procedure FaxFile.Setfile_(Index: Integer; const ATByteDynArray: TByteDynArray);
begin
  Ffile_ := ATByteDynArray;
  Ffile__Specified := True;
end;

function FaxFile.file__Specified(Index: Integer): boolean;
begin
  Result := Ffile__Specified;
end;

procedure FaxFile.SetfileName(Index: Integer; const AWideString: WideString);
begin
  FfileName := AWideString;
  FfileName_Specified := True;
end;

function FaxFile.fileName_Specified(Index: Integer): boolean;
begin
  Result := FfileName_Specified;
end;

procedure FaxFile.SetfileURL(Index: Integer; const AWideString: WideString);
begin
  FfileURL := AWideString;
  FfileURL_Specified := True;
end;

function FaxFile.fileURL_Specified(Index: Integer): boolean;
begin
  Result := FfileURL_Specified;
end;

procedure FaxFile.SetfileType(Index: Integer; const AWideString: WideString);
begin
  FfileType := AWideString;
  FfileType_Specified := True;
end;

function FaxFile.fileType_Specified(Index: Integer): boolean;
begin
  Result := FfileType_Specified;
end;

destructor Fax.Destroy;
var
  I: Integer;
begin
  for I := 0 to Length(Freceiver)-1 do
    FreeAndNil(Freceiver[I]);
  SetLength(Freceiver, 0);
  for I := 0 to Length(Ffiles)-1 do
    FreeAndNil(Ffiles[I]);
  SetLength(Ffiles, 0);
  FreeAndNil(Fsender);
  inherited Destroy;
end;

procedure Fax.Setsender(Index: Integer; const AFaxContactor: FaxContactor);
begin
  Fsender := AFaxContactor;
  Fsender_Specified := True;
end;

function Fax.sender_Specified(Index: Integer): boolean;
begin
  Result := Fsender_Specified;
end;

procedure Fax.Setreceiver(Index: Integer; const AArrayOfFaxContactor: ArrayOfFaxContactor);
begin
  Freceiver := AArrayOfFaxContactor;
  Freceiver_Specified := True;
end;

function Fax.receiver_Specified(Index: Integer): boolean;
begin
  Result := Freceiver_Specified;
end;

procedure Fax.SetsendTime(Index: Integer; const AWideString: WideString);
begin
  FsendTime := AWideString;
  FsendTime_Specified := True;
end;

function Fax.sendTime_Specified(Index: Integer): boolean;
begin
  Result := FsendTime_Specified;
end;

procedure Fax.Setfiles(Index: Integer; const AArrayOfFaxFile: ArrayOfFaxFile);
begin
  Ffiles := AArrayOfFaxFile;
  Ffiles_Specified := True;
end;

function Fax.files_Specified(Index: Integer): boolean;
begin
  Result := Ffiles_Specified;
end;

destructor SendFaxWrapper.Destroy;
begin
  FreeAndNil(Ffax);
  inherited Destroy;
end;

procedure SendFaxWrapper.SetuserID(Index: Integer; const AWideString: WideString);
begin
  FuserID := AWideString;
  FuserID_Specified := True;
end;

function SendFaxWrapper.userID_Specified(Index: Integer): boolean;
begin
  Result := FuserID_Specified;
end;

procedure SendFaxWrapper.SetpassWord(Index: Integer; const AWideString: WideString);
begin
  FpassWord := AWideString;
  FpassWord_Specified := True;
end;

function SendFaxWrapper.passWord_Specified(Index: Integer): boolean;
begin
  Result := FpassWord_Specified;
end;

procedure SendFaxWrapper.SetappCode(Index: Integer; const AWideString: WideString);
begin
  FappCode := AWideString;
  FappCode_Specified := True;
end;

function SendFaxWrapper.appCode_Specified(Index: Integer): boolean;
begin
  Result := FappCode_Specified;
end;

procedure SendFaxWrapper.Setfax(Index: Integer; const AFax: Fax);
begin
  Ffax := AFax;
  Ffax_Specified := True;
end;

function SendFaxWrapper.fax_Specified(Index: Integer): boolean;
begin
  Result := Ffax_Specified;
end;

procedure EFaxResult.SetresultInfo(Index: Integer; const AWideString: WideString);
begin
  FresultInfo := AWideString;
  FresultInfo_Specified := True;
end;

function EFaxResult.resultInfo_Specified(Index: Integer): boolean;
begin
  Result := FresultInfo_Specified;
end;

destructor SendFaxResultWrapper.Destroy;
begin
  FreeAndNil(FsendFaxResult);
  inherited Destroy;
end;

procedure SendFaxResultWrapper.SetsendFaxResult(Index: Integer; const AEFaxResult: EFaxResult);
begin
  FsendFaxResult := AEFaxResult;
  FsendFaxResult_Specified := True;
end;

function SendFaxResultWrapper.sendFaxResult_Specified(Index: Integer): boolean;
begin
  Result := FsendFaxResult_Specified;
end;

procedure SendFaxStateWrapper.SetuserID(Index: Integer; const AWideString: WideString);
begin
  FuserID := AWideString;
  FuserID_Specified := True;
end;

function SendFaxStateWrapper.userID_Specified(Index: Integer): boolean;
begin
  Result := FuserID_Specified;
end;

procedure SendFaxStateWrapper.SetpassWord(Index: Integer; const AWideString: WideString);
begin
  FpassWord := AWideString;
  FpassWord_Specified := True;
end;

function SendFaxStateWrapper.passWord_Specified(Index: Integer): boolean;
begin
  Result := FpassWord_Specified;
end;

procedure SendFaxStateWrapper.SetappCode(Index: Integer; const AWideString: WideString);
begin
  FappCode := AWideString;
  FappCode_Specified := True;
end;

function SendFaxStateWrapper.appCode_Specified(Index: Integer): boolean;
begin
  Result := FappCode_Specified;
end;

procedure SendFaxStateWrapper.SetfaxID(Index: Integer; const AWideString: WideString);
begin
  FfaxID := AWideString;
  FfaxID_Specified := True;
end;

function SendFaxStateWrapper.faxID_Specified(Index: Integer): boolean;
begin
  Result := FfaxID_Specified;
end;

procedure ReceiveFaxWrapper.SetuserID(Index: Integer; const AWideString: WideString);
begin
  FuserID := AWideString;
  FuserID_Specified := True;
end;

function ReceiveFaxWrapper.userID_Specified(Index: Integer): boolean;
begin
  Result := FuserID_Specified;
end;

procedure ReceiveFaxWrapper.SetpassWord(Index: Integer; const AWideString: WideString);
begin
  FpassWord := AWideString;
  FpassWord_Specified := True;
end;

function ReceiveFaxWrapper.passWord_Specified(Index: Integer): boolean;
begin
  Result := FpassWord_Specified;
end;

procedure ReceiveFaxWrapper.Setappcode(Index: Integer; const AWideString: WideString);
begin
  Fappcode := AWideString;
  Fappcode_Specified := True;
end;

function ReceiveFaxWrapper.appcode_Specified(Index: Integer): boolean;
begin
  Result := Fappcode_Specified;
end;

procedure ReceiveFaxWrapper.SetreceiverNumber(Index: Integer; const AWideString: WideString);
begin
  FreceiverNumber := AWideString;
  FreceiverNumber_Specified := True;
end;

function ReceiveFaxWrapper.receiverNumber_Specified(Index: Integer): boolean;
begin
  Result := FreceiverNumber_Specified;
end;

procedure ReceiveFaxWrapper.SetsenderNumber(Index: Integer; const AWideString: WideString);
begin
  FsenderNumber := AWideString;
  FsenderNumber_Specified := True;
end;

function ReceiveFaxWrapper.senderNumber_Specified(Index: Integer): boolean;
begin
  Result := FsenderNumber_Specified;
end;

procedure ReceiveFaxWrapper.SetstartTime(Index: Integer; const AWideString: WideString);
begin
  FstartTime := AWideString;
  FstartTime_Specified := True;
end;

function ReceiveFaxWrapper.startTime_Specified(Index: Integer): boolean;
begin
  Result := FstartTime_Specified;
end;

procedure ReceiveFaxWrapper.SetendTime(Index: Integer; const AWideString: WideString);
begin
  FendTime := AWideString;
  FendTime_Specified := True;
end;

function ReceiveFaxWrapper.endTime_Specified(Index: Integer): boolean;
begin
  Result := FendTime_Specified;
end;

destructor ReceiveFaxResultWrapper.Destroy;
begin
  FreeAndNil(FreceiveFaxResult);
  inherited Destroy;
end;

procedure ReceiveFaxResultWrapper.SetreceiveFaxResult(Index: Integer; const AEFaxResult: EFaxResult);
begin
  FreceiveFaxResult := AEFaxResult;
  FreceiveFaxResult_Specified := True;
end;

function ReceiveFaxResultWrapper.receiveFaxResult_Specified(Index: Integer): boolean;
begin
  Result := FreceiveFaxResult_Specified;
end;

destructor MsgSendReq.Destroy;
begin
  FreeAndNil(FAuthInfo);
  inherited Destroy;
end;

procedure MsgSendReq.SetML(Index: Integer; const AArray_Of_string: Array_Of_string);
begin
  FML := AArray_Of_string;
  FML_Specified := True;
end;

function MsgSendReq.ML_Specified(Index: Integer): boolean;
begin
  Result := FML_Specified;
end;

initialization
  InvRegistry.RegisterInterface(TypeInfo(Iotomessage), 'urn:otomessageIntf-Iotomessage', 'UTF-8');
  InvRegistry.RegisterDefaultSOAPAction(TypeInfo(Iotomessage), 'urn:otomessageIntf-Iotomessage#%operationName%');
  InvRegistry.RegisterReturnParamNames(TypeInfo(Iotomessage), 'return;;' +
                                                              ';;;' +
                                                              ';return;return;return' +
                                                              ';return;return;return' +
                                                              ';return;parameters;parameters' +
                                                              ';parameters');
  InvRegistry.RegisterExternalParamName(TypeInfo(Iotomessage), 'sendFax', 'parameters1', 'parameters');
  InvRegistry.RegisterExternalParamName(TypeInfo(Iotomessage), 'sendFaxState', 'parameters1', 'parameters');
  InvRegistry.RegisterExternalParamName(TypeInfo(Iotomessage), 'receiveFax', 'parameters1', 'parameters');
  RemClassRegistry.RegisterXSClass(AuthInfo, 'urn:ototype', 'AuthInfo');
  RemClassRegistry.RegisterXSClass(MsgSendStatReq, 'urn:ototype', 'MsgSendStatReq');
  RemClassRegistry.RegisterXSClass(MsgInfo, 'urn:ototype', 'MsgInfo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfMsgInfo), 'urn:ototype', 'ArrayOfMsgInfo');
  RemClassRegistry.RegisterXSClass(MsgSearchReq, 'urn:ototype', 'MsgSearchReq');
  RemClassRegistry.RegisterXSClass(MsgRecvInfo, 'urn:ototype', 'MsgRecvInfo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfMsgRecv), 'urn:ototype', 'ArrayOfMsgRecv');
  RemClassRegistry.RegisterXSClass(MsgRecvReq, 'urn:ototype', 'MsgRecvReq');
  RemClassRegistry.RegisterXSClass(MsgSearchCountReq, 'urn:ototype', 'MsgSearchCountReq');
  RemClassRegistry.RegisterXSClass(SQLReq, 'urn:ototype', 'SQLReq');
  RemClassRegistry.RegisterXSClass(FaxContactor, 'urn:ototype', 'FaxContactor');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfFaxContactor), 'urn:ototype', 'ArrayOfFaxContactor');
  RemClassRegistry.RegisterXSClass(FaxFile, 'urn:ototype', 'FaxFile');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FaxFile), 'file_', 'file');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfFaxFile), 'urn:ototype', 'ArrayOfFaxFile');
  RemClassRegistry.RegisterXSClass(Fax, 'urn:ototype', 'Fax');
  RemClassRegistry.RegisterXSClass(SendFaxWrapper, 'urn:ototype', 'SendFaxWrapper');
  RemClassRegistry.RegisterXSClass(EFaxResult, 'urn:ototype', 'EFaxResult');
  RemClassRegistry.RegisterXSClass(SendFaxResultWrapper, 'urn:ototype', 'SendFaxResultWrapper');
  RemClassRegistry.RegisterXSClass(SendFaxStateWrapper, 'urn:ototype', 'SendFaxStateWrapper');
  RemClassRegistry.RegisterXSClass(ReceiveFaxWrapper, 'urn:ototype', 'ReceiveFaxWrapper');
  RemClassRegistry.RegisterXSClass(ReceiveFaxResultWrapper, 'urn:ototype', 'ReceiveFaxResultWrapper');
  RemClassRegistry.RegisterXSInfo(TypeInfo(Array_Of_string), 'http://www.w3.org/2001/XMLSchema', 'Array_Of_string');
  RemClassRegistry.RegisterXSClass(MsgSendReq, 'urn:ototype', 'MsgSendReq');

end.